home *** CD-ROM | disk | FTP | other *** search
/ Eagles Nest BBS 8 / Eagles_Nest_Mac_Collection_Disc_8.TOAST / Developer Tools⁄Additions / MacScheme20 / Contributed / SCOOPS / scoops.doc.part2 < prev    next >
Encoding:
Text File  |  1987-12-14  |  20.5 KB  |  648 lines  |  [TEXT/EDIT]
  1. Material extracted from the TI Scheme Language Reference Manual
  2. with permission of the publisher
  3. Copyright 1985 Texas Instruments Incorporated
  4.  
  5. [If you print this documentation or copy it onto another disk, be sure to
  6. include the above copyright and credit notice.]
  7.  
  8. [The user-contributed implementation of SCOOPS that is distributed with
  9. MacScheme may not support all the features described in this documentation.
  10. We have changed the TI documentation only in places that obviously did not
  11. apply to the MacScheme version.  Our omissions are indicated by ellipses,
  12. and our additions by square brackets -- Semantic Microsystems.]
  13.  
  14. SCOOPS    
  15.  
  16. ALL-CLASSVARS
  17. ALL-INSTVARS
  18. ALL-METHODS
  19. CLASS-COMPILED?
  20. CLASS-OF-OBJECT
  21. CLASSVARS
  22. COMPILE-CLASS
  23. DEFINE-CLASS
  24. DEFINE-METHOD
  25. DELETE-METHOD
  26. DESCRIBE
  27. GETCV
  28. INSTVARS
  29. MAKE-INSTANCE
  30. METHODS
  31. MIXINS
  32. NAME->CLASS
  33. RENAME-CLASS
  34. SEND
  35. SEND-IF-HANDLES
  36. SETCV
  37.  
  38. ----------------------------------------------------------------------
  39. ALL-CLASSVARS
  40.  
  41. ALL-CLASSVARS returns a list of all the class variables in a SCOOPS class.
  42.  
  43. Format:  (ALL-CLASSVARS class)
  44.  
  45. Parameter: class-- A SCOOPS class
  46.  
  47. Explanation: ALL-CLASSVARS returns a list of the names of all the class
  48. variables in class, including the inherited class variables (if class is
  49. compiled or is in the inherited structure).To exclude the inherited class
  50. variables from the listing, use CLASSVARS.
  51.  
  52. Example:  Assume that the class employees exists (as shown in the example for
  53. DEFINE-CLASS) and that is has been compiled with the inherited class variable
  54. soc-sec-no.
  55.  
  56. (all-classvars employees) --> (NO-OF-EMPLOYEES SOC-SEC-NO)
  57.  
  58. ----------------------------------------------------------------------
  59. ALL-INSTVARS
  60.  
  61. ALL-INSTVARS return a list of all the instance variables in a SCOOPS class.
  62.  
  63. Format: (ALL-INSTVARS class)
  64.  
  65. Parameter: class - A SCOOPS class
  66.  
  67. Explanation:  ALL-INSTVARS returns a list of the names of all the instance
  68. variables in class, including the inherited instance variables (if class is
  69. compiled or is in the inherited structure).
  70.  
  71. To exclude the inherited instance variables from the listing, use INSTVARS.
  72.  
  73. Examples: Assume that the class employees exists (as shown in the example for
  74. DEFINE-CLASS) and that it has been compiled with the inherited instance
  75. variable schools.
  76.  
  77. (all-instvars employees) --> (SCHOOLS NAME EMP-NO MANAGER SALARY OVERTIME)
  78.  
  79. ----------------------------------------------------------------------
  80. ALL-METHODS
  81.  
  82. ALL-METHODS returns a list of all the methods of a SCOOPS class.
  83.  
  84. Format: (ALL-METHODS class)
  85.  
  86. Parameter: class - A SCOOPS class
  87.  
  88. Explanation: ALL-METHODS returns a list of the names of all the methods of
  89. class, including the inherited methods (if class is compiled or is in the
  90. inherited structure) and the gettable and settable methods.
  91.  
  92. Examples:  Assume that the class employees exists (as shown in the example 
  93. for DEFINE-CLASS) and that it has been compiled with the inherited instance
  94. variable schools.
  95.  
  96. (all-methods employees) --> (GET-NAME GET-EMP-NO GET-NO-OF-EMPLOYEES
  97.                              GET-SALARY GET-SCHOOLS GET-SOC-SEC-NO
  98.                              SET-NAME SET-EMP-NO SET-MANAGER
  99.                              SET-OVERTIME SET-NO-OF-EMPLOYEES
  100.                              SET-SCHOOLS SET-SOC-SEC-NO)
  101.  
  102. ----------------------------------------------------------------------
  103. CLASS-COMPILED?
  104.  
  105. CLASS-COMPILED? determines whether a SCOOPS class has been compiled.
  106.  
  107. Format: (CLASS-COMPILED? class)
  108.  
  109. Parameter:  class - A SCOOPS class
  110.  
  111. Explanation:  CLASS-COMPILED? returns true if class has been compiled and
  112. false, otherwise. 
  113.  
  114. To compile a SCOOPS class, use COMPILE-CLASS.
  115.  
  116. Examples:  Assume that the class employees exists and that it has not been
  117. compiled.
  118.  
  119. (class-compiled? employees) --> false
  120.  
  121. (compile-class emloyees) --> unspecified value
  122.  
  123. (class-compiled? employees) --> true
  124.  
  125. ----------------------------------------------------------------------
  126. CLASS-OF-OBJECT
  127.  
  128. CLASS-OF-OBJECT  returns the name of an object's SCOOPS class.
  129.  
  130. Format:  (CLASS-OF-OBJECT object)
  131.  
  132. Parameter:  object - an instance of a SCOOPS class
  133.  
  134. Explanation:  CLASS-OF-OBJECT returns the name of the class to which object
  135. belongs.
  136.  
  137. Example:  Assume that the class employees exists (as shown in the example
  138. for DEFINE-CLASS).
  139.  
  140. (define emp1 (make-instance employees)) --> unspecified value
  141.  
  142. (class-of-object emp1) --> EMPLOYEES
  143.  
  144. ----------------------------------------------------------------------
  145. CLASSVARS
  146.  
  147. CLASSVARS returns a list of the class variables defined in a SCOOPS class.
  148.  
  149. Format:  (CLASSVARS class)
  150.  
  151. Parameter:  class - A SCOOPS class
  152.  
  153. Explanation: CLASSVARS returns a list of the names of the class variables in
  154. class.  This list does not include the inherited class variables.
  155.  
  156. To include the inherited class variables in the listing, use  ALL-CLASSVARS.
  157.  
  158. Examples:  Assume that the class employees exists (as shown in the example 
  159. for DEFINE-CLASS) and that it has been compiled with the inherited class 
  160. variable soc-sec-no.
  161.  
  162. (classvars employees) --> (NO-OF-EMPLOYEES)
  163.  
  164. ----------------------------------------------------------------------
  165. COMPILE-CLASS
  166.  
  167. COMPILE-CLASS compiles the given SCOOPS class.
  168.  
  169. Format:  (COMPILE-CLASS class)
  170.  
  171. Parameter:  class - A SCOOPS class
  172.  
  173. Explanation:  COMPILE-CLASS compiles class.  An unspecified value is 
  174. returned.  The variables and methods of class are inherited from its mixins.
  175.  
  176. Example:  Assume that the class employees exists (as shown in the example for
  177. DEFINE-CLASS) and that it has not been compiled.
  178.  
  179. (class-compiled? employees) --> false
  180.  
  181. (compile-class employees) --> unspecified value
  182.  
  183. (class-compiled? employees) --> true
  184.  
  185. ----------------------------------------------------------------------
  186. DEFINE-CLASS
  187.  
  188. DEFINE-CLASS defines a SCOOPS class.
  189.  
  190. Format:  (DEFINE-CLASS name (optional-attributes) ...)
  191.  
  192. Parameters:  name-The name of the SCOOPS class being defined.
  193.  
  194.              optional-attibutes...-The description of the SCOOPS class
  195.              consisting of any of the following:
  196.  
  197. CLASSVARS followed by the names of the class variables.  A variable can be
  198. initialized by putting its name and initial value in a list.  The initial
  199. value is evaluated when the class is compiled.  If no initial value is
  200. specified, the variable remains unbound.
  201.  
  202. INSTVARS followed by the names of the instance variables.  A variable can be
  203. initialized by putting its name and initial value in a list.  The initial
  204. value is evaluated when the instance of the class is created.  The initial
  205. value for an instance variable could be an active value.
  206.  
  207. MIXINS followed by the names of the component classes.
  208.  
  209. OPTIONS followed by the keywords GETTABLE-VARIABLES, SETTABLE-VARIABLES, or
  210. INITTABLE-VARIABLES.   These keywords can be given either with arguments that
  211. are class and instance variables or without arguments, in which case the
  212. keyword refers to all the class and instance variables.   To associate
  213. arguments with a keyword, put the keyword and its arguments in a list.
  214.  
  215. Explanation:  DEFINE-CLASS defines a SCOOPS class, named name, consisting of
  216. optional-attributes.  An unspecified value is returned.
  217.  
  218. Note that instance variables can have active values associated with them. 
  219. These values are declared in optional-attributes after the keyword INSTVARS 
  220. as follows:
  221.  
  222. (name (active init-value getfn setfn))
  223.  
  224. The value init-value is the initial value of name.  Whenever name is accessed
  225. with GET-name, the current value of name is passed to getfn (a procedure of
  226. one argument), and the value returned by getfn is the value returned by
  227. GET-name.  Whenever the value of name is changed with SET-name, the new value
  228. is passed to setfn (a procedure of one argument), and the value returned by
  229. setfn is the new value of name.  Active values may be nested to an arbitrary
  230. depth by specifying another active value as the init-value of an active value.
  231.  
  232. Example:  In this example, a class named employees is created.  Its inherited
  233. classes will be personal-info and education-experience.
  234.  
  235. (define-class employees
  236.   (classvars (no-of-employees 0))
  237.   (instvars name emp-no manager salary (overtime 0))
  238.   (mixins personal-info education-experience)
  239.   (options
  240.    (gettable-variables name emp-no no-of-employees)
  241.    settable-variables
  242.    inittable-variables)) --> unspecified value
  243.  
  244. ----------------------------------------------------------------------
  245. DEFINE-METHOD
  246.  
  247. DEFINE-METHOD defines a method for a SCOOPS class.
  248.  
  249. Format:  (DEFINE-METHOD (class method) lambdalist body)
  250.  
  251. Parameters:  class - A SCOOPS class
  252.              method - The name of the method being defined
  253.              lambdalist - The list of the formal parameters of the method 
  254.              body - The body of the method    
  255.  
  256. Explanation:  DEFINE-METHOD defines a method that determines the behavior of
  257. class.  An unspecified value is returned.  If a method with the same name
  258. exists already for class, this definition replaces the previous definition. 
  259. Also, this definition applies to all subclasses of class.
  260.  
  261. Example:  This example defines a class named employees and its methods. 
  262. Notice that name, emp-no, salary, and overtime are instance variables of
  263. employees and thus are accessed directly instead of by using the get methods.
  264.  
  265. (define-class employees
  266.   (classvars (no-of-employees 0))
  267.   (instvars name emp-no manager salary (overtime 0))
  268.   (mixins personal-info education-experience)
  269.   (options
  270.    (gettable-variables name emp-no no-of-employees)
  271.    settable-variables
  272.    inittable-variables)) --> unspecified value
  273.  
  274. (define-method (employees earnings) ()
  275.   (+ salary overtime)) --> unspecified value
  276.  
  277. (define-method
  278.   (employees earnings-greater-than)  (val)
  279.   (if (> (earnings) val)
  280.       (writeln name "  " emp-no)
  281.       #f)) --> unspecified value
  282.  
  283. (define emp1
  284.   (make-instance employees
  285.     'name 'RALPH
  286.     'emp-no 001
  287.     'manager 'SAM
  288.     'salary 100)) --> unspecified value
  289.  
  290. (send emp1 earnings-greater-than 99) --> false
  291. RALPH 1
  292.  
  293. ----------------------------------------------------------------------
  294. DELETE-METHOD
  295.  
  296. DELETE-METHOD deletes a method for a SCOOPS class.
  297.  
  298. Format:  (DELETE-METHOD (class method))
  299.  
  300. Parameters:  class - A SCOOPS class
  301.  
  302. Explanation:  DELETE-METHOD deletes method from class.  An unspecified value
  303. is returned.  If method is not defined in class, an error results.  All the
  304. subclasses of class notice the deletion.
  305.  
  306. Examples:  Assume that the class employees exists (as shown in the example 
  307. for DEFINE-CLASS) with the method earnings (as shown in the example for
  308. DEFINE-METHOD). The following example deletes the method earnings from
  309. employees:
  310.  
  311. (delete-method (employee earnings)) --> unspecified value
  312.  
  313. ----------------------------------------------------------------------
  314. DESCRIBE
  315.  
  316. DESCRIBE prints the description of a SCOOPS class or SCOOPS object.
  317.  
  318. Format:  (DESCRIBE class-or-object)
  319.  
  320. Parameter:  class-or-object - A SCOOPS class or an instance of a SCOOPS class
  321.  
  322. Explanation:  DESCRIBE prints a description of class-or-object to the current
  323. output port. An unspecified value is returned.
  324.  
  325. If class-or-object is a class, DESCRIBE prints the list of class variables,
  326. instance variables, and methods and tells wheter the class has been compiled
  327. and whether the class has been compiled and whether the class has been
  328. inherited.
  329.  
  330. If class-or-object is an instance of a class, DESCRIBE prints the names and
  331. the values of the class as well as the instance variables.
  332.  
  333. Example:  Assume that the classes employees, personal-info, and
  334. education-experience exist, with personal-info having the single class
  335. variable soc-sec-no and education-experience having the instance variable
  336. schools.
  337.  
  338. (describe employees)
  339.  
  340. CLASS DESCRIPTION
  341.  
  342. NAME                 :  EMPLOYEES
  343. CLASSVARS            :  (SOC-SEC-NO NO-OF-EMPLOYEES)
  344. INSTANCE VARS        :  (SCHOOLS NAME EMP-NO MANAGER SALARY OVERTIME)
  345. METHODS              :  (SET-NO-OF-EMPLOYEES SET-NAME
  346.                       SET-EMP-NO SET-MANAGER SET-SALARY SET-OVERTIME
  347.                       SET-SOC-SEC-NO SET-SCHOOLS GET-NAME GET-EMP-NO
  348.                       GET-NO-OFEMPLOYEES GET-SOC-SEC-NO GET-SCHOOLS)
  349. MIXINS               :  (PERSONAL-INFO EDUCATION-EXPERIENCE)
  350. CLASS COMPILED       :  #T
  351. CLASS INHERITED      :  #T
  352.  
  353.  --> unspecified value
  354.  
  355. ----------------------------------------------------------------------
  356. GETCV
  357.  
  358. GETCV returns the value of a SCOOPS class variable.
  359.  
  360. Format:  (GETCV class var)
  361.  
  362. Parameters:  class-A SCOOPS class
  363.              var-The name of a class variable defined in class
  364.  
  365. Explanation:  GETCV returns the value of var in class.  If class has not been
  366. compiled or var has not been described as gettable in DEFINE-CLASS, an error
  367. results.
  368.  
  369. Examples:  Assume that the class employees has been defined (as shown in the
  370. example for DEFINE-CLASS).
  371.  
  372. (setcv employees no-of-employees 1000) --> unspecified value
  373.  
  374. (getcv employees no-of-employees) --> 1000
  375.  
  376. ----------------------------------------------------------------------
  377. INSTVARS
  378.  
  379. INSTVARS returns a list of the instance variables defined in a SCOOPS class.
  380.  
  381. Formats:  (INSTVARS class)
  382.  
  383. Parameter:  class-A SCOOPS class 
  384.  
  385. Explanation:  INSTVARS returns a list of the names of the instance variables
  386. defined in class.  This list does not inclued the inherited instance
  387. variables.
  388.  
  389. To inclued the inherited instance variables in the listing, use the procedure
  390. ALL-INSTVARS.
  391.  
  392. Examples:  Assume that the class employees exists as shown in the example for
  393. DEFINE-CLASS.
  394.  
  395. (instvars employees) --> (NAME EMP-NO MANAGER SALARY    OVERTIME)
  396.  
  397. ----------------------------------------------------------------------
  398. MAKE-INSTANCE
  399.  
  400. MAKE-INSTANCE creates an instance of a SCOOPS class.
  401.  
  402. Format:  (MAKE-INSTANCE class var init-val . . .)
  403.  
  404. Parameters:  class-A SCOOPS class
  405.              var . . .-The variables in class whose values are to be
  406.              initialized
  407.              init-val . .-The initial values for each var
  408.  
  409. Explanation:  MAKE-INSTANCE evaluates var and init-val and then returns an
  410. instance of class, which is an environment.  This special form can be used to
  411. specify initial values for instance variables that have been described as
  412. itittable in DEFINE-CLASS.
  413.  
  414. Example:
  415.  
  416. (define-class employees
  417.   (classvars (no-of-employees ))
  418.   (instvars name emp-no manager salary (overtime ))
  419.   (mixins personal-info education-experience)
  420.   (options
  421.    (gettable-variables name emp-no no-of-employees)
  422.    settable-variables
  423.    inittable-variables)) --> unspecified value
  424.  
  425. (define-method (employees earnings) ()
  426.   (+ salary overtime)) --> unspecified value
  427.  
  428. (define-method
  429.   (employees earnings-greater-than) (val)
  430.   (if (>? (earnings) val)
  431.       (writeln name "  " emp-no)
  432.       #F)) --> unspecified value
  433.  
  434. (define emp1
  435.   (make-instance employees
  436.    'name 'RALPH
  437.    'emp-no 001
  438.    'manager 'SAM
  439.    'salary 100)) --> unspecified value
  440.  
  441. (send emp1 earnings-greater-than 99) --> false
  442. RALPH 1
  443.  
  444. ----------------------------------------------------------------------
  445. METHODS
  446.  
  447. METHODS returns a list of the methods defined in a SCOOPS class.
  448.  
  449. Format:  (METHODS class)
  450.  
  451. Parameter: class - A SCOOPS class
  452.  
  453. Explanation:  METHODS returns a list of the names of the methods defined in
  454. class.   This list does not included the inherited methods.
  455.  
  456. To include the inherited methods in the listing, use ALL-METHODS.
  457.  
  458. Example:  Assume that the class employees exists (as shown in the example for
  459. DEFINE-CLASS) and that it has been compiled with the inherited instance
  460. variable schools and the inherited class variable soc-sec-no.
  461.  
  462. (methods employees) --> (GET-NAME GET-EMP-NO GET-NO-OF-EMPLOYEES
  463.                          GET-SALARY SET-EMP-NO SET-MANAGER SET-OVERTIME
  464.                          SET-NO-OF-EMPLOYEES)
  465.  
  466. ----------------------------------------------------------------------
  467. MIXINS
  468.  
  469. MIXINS returns a list of the mixins of a SCOOPS class.
  470.  
  471. Format:  (MIXINS class)
  472.  
  473. Parameter:  class-A SCOOPS class.
  474.  
  475. Explanation:  MIXINS returns a list of the mixins of class.
  476.  
  477. Examples:  Assume that the class employees exists (as shown in the example 
  478. for DEFINE-CLASS).
  479.  
  480. (mixins employees) --> (PERSONAL-INFO EDUCATION-EXPERIENCE)
  481.  
  482. ----------------------------------------------------------------------
  483. NAME->CLASS
  484.  
  485. NAME->CLASS returns the SCOOPS class with the specified name.
  486.  
  487. Format:  (NAME->CLASS class)
  488.  
  489. Parameter:  class-The name of a SCOOPS class
  490.  
  491. Explanation:  NAME->CLASS returns the SCOOPS class with the name class.
  492.  
  493. Example:  Assume that the class employees exists (as shown in the example for
  494. DEFINE-CLASS).
  495.  
  496. (name->class 'employees) --> scoops-class
  497.  
  498. ----------------------------------------------------------------------
  499. RENAME-CLASS
  500.  
  501. RENAME-CLASS renames a SCOOPS class.
  502.  
  503. Format:  (RENAME-CLASS (class new-name))
  504.  
  505. Parameters:  class-A SCOOPS class
  506.              new-name-The new name for the SCOOPS class
  507.  
  508. Explanation:  RENAME-CLASS renames class as new-name.  An unspecified value 
  509. is returned.
  510.  
  511. Examples:  Assume that the class employees exists ( as shown in the example
  512. for DEFINE-CLASS).
  513.  
  514. (rename-class (employees slaves))      unspecified value
  515.  
  516. ----------------------------------------------------------------------
  517. SEND
  518.  
  519. SEND sends a message to an object in a SCOOPS class
  520.  
  521. Format:  (SEND object msg arg ...)
  522.  
  523. Parameters:  object - An instance of a SCOOPS class
  524.              msg - The name of the message to be sent
  525.              arg... - The arguments to the method associated with the message
  526.  
  527. Explanation:  SEND sends msg to object, applies the method associated with 
  528. msg to the arguments (arg . . .), and returns the result of the application.  
  529. SEND evaluates object and its arguments (arg . . .) but does not evaluated 
  530. msg.  The maximum number of arguments to the method that can be specified in 
  531. SEND is 8.  If object cannot handle msg, an error results.
  532.  
  533. See also SEND-IF-HANDLES.
  534.  
  535. Examples:
  536.  
  537. (define-class employees
  538.   (classvars (no-of-employees 0))
  539.   (instvars name emp-no manager salary (overtime 0))
  540.   (mixins personal-info education-experience)
  541.   (options    
  542.    (gettable-variables name emp-no no-of-employees)
  543.    settable-variables
  544.    inittable-variables)) --> unspecified value
  545.  
  546. (define-method (employees earnings)  ()
  547.   (+ salary overtime)) --> unspecified value
  548.  
  549. (define-method
  550.   (employees earnings-greater-than) (val)
  551.   (if (>? (earnings) val)
  552.       (writeln name " " emp-no)
  553.       #F)) --> unspecified value
  554.  
  555. (define emp1
  556.   (make-instance employees
  557.       'name 'RALPH
  558.       'emp-no 001
  559.       'manager 'SAM
  560.       'salary 100)) --> unspecified value
  561.  
  562. (send emp1 get-name) --> RALPH
  563.  
  564. (send emp1 earnings) --> 100
  565.  
  566. (send emp1 set-overtime 100) --> unspecified value
  567.  
  568. (send emp1 earnings) --> 200
  569.  
  570. ----------------------------------------------------------------------
  571. SEND-IF-HANDLES
  572.  
  573. SEND-IF-HANDLES  sends a message to a SCOOPS object only if the object can
  574. handle the message.
  575.  
  576. Format:  (SEND-IF-HANDLES object msg arg . . .)
  577.  
  578. Parameters:  object - An instance of a SCOOPS class
  579.              msg - The name of the message to be sent
  580.              arg ...- The arguments to the method associated with the message
  581.  
  582. Explanation:  SEND-IF-HANDLES sends msg to object only if object can handle
  583. msg, applies the method associated with msg to the arguments (arg...), and
  584. returns the result of the application.  SEND-IF-HANDLES evaluates object and
  585. its arguments (arg...)‚ but does not evaluate msg.  The maximum number  of
  586. arguments to the method that can be specified in SEND-IF-HANDLES is 8. If
  587. object cannot handle msg, false is returned.
  588.  
  589. See also SEND.
  590.  
  591. Examples:
  592.  
  593. (define-class employees
  594.   (classvars (no-of-employees 0))
  595.   (instvars name emp-no manager salary (overtime 0))
  596.   (mixins personal-info education-experience)
  597.   (options
  598.    (gettable-variables name emp-no no-of-employees)
  599.    settable-variables
  600.    inittable-variables)) -->    unspecified value
  601.  
  602. (define-method (employees earnings) ()
  603.   (+ salary overtime)) --> unspecified value
  604.  
  605. (define-method
  606.   (employees earnings-greater-than) (val)
  607.   (if (>? (earnings) val)
  608.       (writeln name " " emp-no)
  609.       #F)) --> unspecified value
  610.  
  611. (define emp1
  612.   (make-instance employees
  613.      'name 'RALPH
  614.      'emp-no 001
  615.      'manager 'SAM
  616.      'salary 100)) --> unspecified value
  617.  
  618. (send-if-handles emp1 get-name) --> RALPH
  619.  
  620. (send-if-handles emp1 earnings) --> 100
  621.  
  622. (send-if-handles emp1 set-overtime 100) --> unspecified value
  623.  
  624. (send-if-handles emp1 get-value) --> false
  625.  
  626. ----------------------------------------------------------------------
  627. SETCV
  628.  
  629. SETCV changes the value of a SCOOPS class variable.
  630.  
  631. Format:  (SETCV class var exp)
  632.  
  633. Parameters:  class - A SCOOPS class
  634.              var - The name of a class variable defined in class
  635.              exp - The value to be stored in var
  636.  
  637. Explanation:  SETCV stores the value of exp in the var in class.  An
  638. unspecified value is returned.  If class has not been compiled or var has not
  639. been described as settable in DEFINE-CLASS, an error results.
  640.  
  641. Examples:  Assume that the class employees has been defined as shown in the
  642. example for DEFINE-CLASS.
  643.  
  644. (setcv employees no-of-employees 1000) --> unspecified value
  645.  
  646. (getcv employees no-of-employees) --> 1000 
  647.  
  648.